
///////////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) 2002, Perry L Miller IV
//  All rights reserved.
//  BSD License: http://www.opensource.org/licenses/bsd-license.html
//
///////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////
//
//  Convenient base class.
//
///////////////////////////////////////////////////////////////////////////////

#include "Usul/Base/Object.h"

#include "Usul/Functions/SafeCall.h"

#include "boost/bind.hpp"

using namespace Usul::Base;


///////////////////////////////////////////////////////////////////////////////
//
//  Constructor.
//
///////////////////////////////////////////////////////////////////////////////

Object::Object() : BaseClass(),
  _name     (),
  _mutex    ( new Object::Mutex )
{
}


///////////////////////////////////////////////////////////////////////////////
//
//  Constructor.
//
///////////////////////////////////////////////////////////////////////////////

Object::Object ( const std::string& name ) : BaseClass(),
_name     ( name ),
_mutex    ( new Object::Mutex )
{
}


///////////////////////////////////////////////////////////////////////////////
//
//  Copy constructor.
//
///////////////////////////////////////////////////////////////////////////////

Object::Object ( const Object &m ) : BaseClass ( m ),
  _name       (),
  _mutex      ( new Object::Mutex )
{
  Guard guard ( m.mutex() );

  _name = m._name;
}


///////////////////////////////////////////////////////////////////////////////
//
//  Assignment.
//
///////////////////////////////////////////////////////////////////////////////

Object &Object::operator = ( const Object &m )
{
  Guard guard1 ( this->mutex() );
  Guard guard2 ( m.mutex() );

  _name = m._name;

  return *this;
}


///////////////////////////////////////////////////////////////////////////////
//
//  Destructor.
//
///////////////////////////////////////////////////////////////////////////////

Object::~Object()
{
  Usul::Functions::safeCall ( boost::bind ( &Object::_destroy, this ), "1729453311" );
}


///////////////////////////////////////////////////////////////////////////////
//
//  Destroy the object.
//
///////////////////////////////////////////////////////////////////////////////

void Object::_destroy()
{

  _name.clear();
  delete _mutex; _mutex = 0x0;
}


///////////////////////////////////////////////////////////////////////////////
//
//  Set the name.
//
///////////////////////////////////////////////////////////////////////////////

void Object::name ( const std::string &n )
{
  Guard guard ( this->mutex() );
  _name = n;
}


///////////////////////////////////////////////////////////////////////////////
//
//  Get the name.
//
///////////////////////////////////////////////////////////////////////////////

std::string Object::name() const
{
  Guard guard ( this->mutex() );
  return std::string ( _name.begin(), _name.end() ); // More thread-safe?
}


///////////////////////////////////////////////////////////////////////////////
//
//  Get the mutex.
//
///////////////////////////////////////////////////////////////////////////////

Object::Mutex &Object::mutex() const
{
  return *_mutex;
}
